import { ref } from 'vue'
import * as XLSX from 'xlsx'
import { ElMessage } from 'element-plus'

/**
 * Excel导入Hook
 */
export function useExcelImport() {
  const importData = ref<any[]>([])
  const loading = ref(false)
  const error = ref<Error | null>(null)

  /**
   * 读取Excel文件
   * @param file Excel文件
   * @param headerMap 表头映射，用于将Excel表头映射到数据库字段
   * @param sheetName 指定要读取的工作表名，如果不指定则读取第一个工作表
   * @returns 处理后的数据
   */
  const readExcelFile = async (file: File, headerMap?: Record<string, string>, sheetName?: string) => {
    loading.value = true
    error.value = null
    importData.value = []

    try {
      // 读取文件
      const data = await readFile(file)
      
      // 解析Excel
      const workbook = XLSX.read(data, { type: 'array' })
      
      // 获取工作表
      let worksheet
      if (sheetName && workbook.SheetNames.includes(sheetName)) {
        // 如果指定了工作表名且存在，则使用指定的工作表
        worksheet = workbook.Sheets[sheetName]
      } else {
        // 否则使用第一个工作表
        const firstSheetName = workbook.SheetNames[0]
        worksheet = workbook.Sheets[firstSheetName]
        
        // 如果指定了工作表但不存在，给出警告
        if (sheetName) {
          console.warn(`指定的工作表 "${sheetName}" 不存在，已使用第一个工作表 "${firstSheetName}"`)
        }
      }
      
      // 转换为JSON
      const jsonData = XLSX.utils.sheet_to_json(worksheet, {
        raw: false, // 将日期作为字符串处理
        defval: null // 空单元格使用null
      })
      
      // 如果有表头映射，则进行字段映射
      if (headerMap) {
        const mappedData = jsonData.map((row: any) => {
          const mappedRow: Record<string, any> = {}
          
          // 遍历原始数据的每个字段
          Object.keys(row).forEach(key => {
            // 查找映射关系
            const mappedKey = headerMap[key]
            
            // 如果有映射关系，则使用映射后的字段名
            if (mappedKey) {
              // 处理日期字段
              if (mappedKey === 'hire_date' || mappedKey === 'leave_date') {
                // 如果值为空，直接设置为null
                if (!row[key] || row[key].trim() === '') {
                  mappedRow[mappedKey] = null
                  return mappedRow
                }
                
                // 尝试解析日期
                const date = new Date(row[key])
                if (!isNaN(date.getTime())) {
                  mappedRow[mappedKey] = date.toLocaleDateString('zh-CN', { 
                    year: 'numeric', 
                    month: '2-digit', 
                    day: '2-digit' 
                  }).replace(/\//g, '-')
                } else {
                  mappedRow[mappedKey] = null
                }
              } else {
                mappedRow[mappedKey] = row[key]
              }
            } else {
              // 没有映射关系，保持原字段名
              mappedRow[key] = row[key]
            }
          })
          
          return mappedRow
        })
        
        importData.value = mappedData
      } else {
        importData.value = jsonData as any[]
      }
      
      ElMessage.success(`成功导入 ${importData.value.length} 条数据`)
      return importData.value
    } catch (err) {
      error.value = err as Error
      ElMessage.error(`导入失败: ${(err as Error).message}`)
      return []
    } finally {
      loading.value = false
    }
  }

  /**
   * 读取文件为ArrayBuffer
   * @param file 文件对象
   * @returns Promise<ArrayBuffer>
   */
  const readFile = (file: File): Promise<ArrayBuffer> => {
    return new Promise((resolve, reject) => {
      const reader = new FileReader()
      
      reader.onload = (e) => {
        if (e.target?.result) {
          resolve(e.target.result as ArrayBuffer)
        } else {
          reject(new Error('读取文件失败'))
        }
      }
      
      reader.onerror = (e) => {
        reject(new Error('读取文件出错'))
      }
      
      reader.readAsArrayBuffer(file)
    })
  }

  /**
   * 验证导入的数据
   * @param data 导入的数据
   * @param requiredFields 必填字段
   * @returns 验证结果
   */
  const validateImportData = (data: any[], requiredFields: string[]) => {
    if (!data || data.length === 0) {
      ElMessage.error('导入的数据为空')
      return false
    }
    
    // 检查必填字段
    for (let i = 0; i < data.length; i++) {
      const row = data[i]
      
      for (const field of requiredFields) {
        if (row[field] === undefined || row[field] === null || row[field] === '') {
          ElMessage.error(`第 ${i + 1} 行数据缺少必填字段: ${field}`)
          return false
        }
      }
    }
    
    return true
  }

  return {
    importData,
    loading,
    error,
    readExcelFile,
    validateImportData
  }
} 